home *** CD-ROM | disk | FTP | other *** search
/ Clickx 115 / Clickx 115.iso / software / tools / windows / tails-i386-0.16.iso / live / filesystem.squashfs / usr / include / scribus-ng / desaxe / digester.h < prev    next >
Encoding:
C/C++ Source or Header  |  2009-03-09  |  8.1 KB  |  410 lines
  1. /*
  2.  *  digester.h
  3.  *  
  4.  *
  5.  *  Created by Andreas Vox on 02.06.06.
  6.  *  Copyright 2006 under GPL2. All rights reserved.
  7.  *
  8.  */
  9.  
  10.  
  11.  
  12. #ifndef DIGESTER_H
  13. #define DIGESTER_H
  14.  
  15. #include <cassert>
  16. #include <iostream>
  17. #include <vector>
  18. #include <map>
  19. #include <string>
  20. #include <typeinfo>
  21.  
  22. #include "desaxe_conf.h"
  23. #include "saxhandler.h"
  24.  
  25.  
  26. //#define DESAXE_DEBUG 1
  27.  
  28. namespace desaxe {
  29.     
  30. class Action;
  31. class RuleState;
  32.  
  33.  
  34. namespace PRIVATE {
  35.     
  36.     class VarPtr
  37.     {
  38.     public:
  39.         void* ptr;
  40.         std::string type;
  41.     };
  42.  
  43.     
  44.     template<class ObjType>
  45.     inline
  46.     VarPtr mkcell(ObjType* obj)
  47.     {
  48.         VarPtr result;
  49.         result.ptr = obj;//    result.ptr = const_cast<void*>(static_cast<const void*>(obj)); //??
  50.         result.type = typeid(obj).name();
  51.         return result;
  52.     }
  53.     
  54.     
  55.     template<class ObjType>
  56.     inline
  57.     void chkcell(const VarPtr& cell, std::vector<VarPtr>* stack = NULL)
  58.     {
  59.         ObjType* dummy = NULL;
  60.         if( cell.type != typeid(dummy).name() )
  61.         {
  62.             std::cerr << "requested type '" << typeid(dummy).name() << "' doesnt match cell type '" << cell.type << "'\n";
  63.             if (stack)
  64.             {
  65.                 int i=0;
  66.                 std::vector<VarPtr>::iterator it;
  67.                 for (it = stack->begin(); it != stack->end(); ++it)
  68.                 {
  69.                     std::cerr << i++ << "\t" << (*it).type << "\t" << (*it).ptr << "\n";
  70.                 }
  71.             }
  72.             assert (false);
  73.         }
  74.     }
  75.     
  76.  
  77.  
  78. class Patch {
  79. public:
  80.     // internal linked list
  81.     Patch* next;
  82.     Patch(Patch* nxt) : next(nxt) {}
  83.     
  84.     virtual void run(VarPtr lnk) = 0;
  85.     virtual ~Patch() {}
  86. };
  87.  
  88.  
  89. } // namespace PRIVATE    
  90.  
  91.  
  92.  
  93. /**
  94.    Digester helps you to create C++ objects from a SAX stream.
  95.    All you have to do is register actions for patterns of element tags
  96.    you expect in your XML stream. These actions can create new objects, set
  97.    attributes, or call methods. Actions operate on intermediate objects which 
  98.    are hold on a stack maintained by Digester.  
  99.  */
  100. class Digester : public SaxHandler {    
  101. public:
  102.     Digester();
  103.     Digester& operator=(const Digester& other);
  104.     virtual ~Digester();
  105.     void addRule(const Xml_string& pattern, Action action);
  106.     
  107.     void parseFile(const Xml_string& filename);
  108.     void parseMemory(const char* data, unsigned int length);
  109.     
  110.     template<class ObjType>
  111.         ObjType*  result();    
  112.     int nrOfErrors() const;
  113.     const Xml_string getError(int i) const;
  114.     
  115. // called by SAX parser:
  116.     void beginDoc();
  117.     void endDoc();
  118.     void begin(const Xml_string& tag, Xml_attr attr);
  119.     void end(const Xml_string& tag);
  120.     void chars(const Xml_string& text);
  121.     
  122. // used by actions:
  123.     void fail();
  124.     void error(const Xml_string& msg);
  125.     
  126.     template<class ObjType>
  127.     ObjType*  top(unsigned int offset = 0);
  128.     
  129.     template<class ObjType>
  130.     ObjType*  bottom(unsigned int offset = 0);
  131.     
  132.     template<class ObjType>
  133.     void setResult(    ObjType* res );
  134.     
  135.     void pop();
  136.     void popn(unsigned int number);
  137.     
  138.     template<class ObjType>
  139.     void push(ObjType* obj);
  140.     
  141. //  used to resolve idrefs and for general storage    
  142.     template<class ObjType>
  143.         ObjType*  lookup(const Xml_string& idref);    
  144.     template<class ObjType>
  145.         void store(const Xml_string& idref, ObjType* res );
  146.     
  147. //  used to resolve idrefs if use is before definition
  148.     template<class LinkType>
  149.         void patchCall(const Xml_string& idref, void (*fun)(LinkType*) );
  150.     template<class ObjType, class LinkType>
  151.         void patchInvoke(const Xml_string& idref, ObjType* obj, void (ObjType::*fun)(LinkType*) );
  152.     
  153.     // used to insert "/" where necessary
  154.     static Xml_string concat(const Xml_string& pattern1, const Xml_string& pattern2);
  155.  
  156. private:
  157.     RuleState* 
  158.         state;
  159.     
  160.     std::vector<PRIVATE::VarPtr> 
  161.         objects;
  162.     
  163.     std::map<Xml_string, PRIVATE::VarPtr> 
  164.         storage;
  165.  
  166.     std::map<Xml_string, PRIVATE::Patch*>
  167.         patches;
  168.     
  169.     PRIVATE::VarPtr 
  170.         result_;
  171.     
  172.     std::vector<Xml_string> 
  173.         errors;
  174. };
  175.  
  176.  
  177.  
  178. template<class ObjType>
  179. inline
  180. ObjType*  Digester::top(unsigned int offset) 
  181. {
  182. #ifdef DESAXE_DEBUG
  183.     std::cerr << "top(" << offset << ") of " << objects.size() << "\n";
  184. #endif
  185.     unsigned int count = objects.size();
  186.     assert (offset < count); 
  187.     PRIVATE::chkcell<ObjType>(objects[count - offset - 1], &objects);
  188. #ifdef DESAXE_DEBUG
  189.     std::cerr << "stack-> " << static_cast<ObjType*>(objects[count - offset - 1].ptr) << "\n";
  190. #endif
  191.     
  192.     return static_cast<ObjType*>(objects[count - offset - 1].ptr);
  193. }
  194.  
  195.  
  196. template<class ObjType>
  197. inline
  198. ObjType*  Digester::bottom(unsigned int offset) 
  199. { 
  200. #ifdef DESAXE_DEBUG
  201.     std::cerr << "bottom(" << offset << ") of " << objects.size() << "\n";
  202. #endif
  203.     unsigned int count = objects.size();
  204.     assert (offset < count); 
  205.     PRIVATE::chkcell<ObjType> (objects[offset]);
  206.     return static_cast<ObjType*>(objects[offset].ptr);
  207. }
  208.  
  209.  
  210. template<class ObjType>
  211. inline
  212. ObjType*  Digester::result() 
  213. { 
  214.     ObjType* dummy = NULL;
  215.     if (result_.type != typeid(dummy).name())
  216.         return NULL;
  217. #ifdef DESAXE_DEBUG
  218.     std::cerr << "result-> " << static_cast<ObjType*>(result_.ptr) << "\n";
  219. #endif
  220.     return static_cast<ObjType*>(result_.ptr);
  221. }
  222.  
  223.  
  224. template<class ObjType>
  225. inline
  226. void Digester::setResult(ObjType* res) 
  227. { 
  228. #ifdef DESAXE_DEBUG
  229.     std::cerr << res << " ->result\n";
  230. #endif
  231.     result_ = PRIVATE::mkcell(res);
  232. }
  233.  
  234.  
  235. inline
  236. void Digester::pop()
  237. {
  238.     assert (1 <= (unsigned int) objects.size());
  239.     objects.pop_back();
  240. }
  241.  
  242. inline
  243. void Digester::popn(unsigned int number)
  244. {
  245.     unsigned int count = (unsigned int) objects.size();
  246.     assert (number <= count);
  247.     objects.resize(count - number);
  248. }
  249.  
  250.  
  251. template<class ObjType>
  252. inline
  253. void Digester::push(ObjType* obj)
  254. {
  255. #ifdef DESAXE_DEBUG
  256.     std::cerr << "stack<- " << obj << "\n";
  257. #endif
  258.     objects.push_back(PRIVATE::mkcell(obj));
  259. }
  260.  
  261.  
  262. // now lookup / store / patch business
  263.  
  264. namespace PRIVATE {
  265.     
  266.     template <class LinkType>
  267.     struct Patch1 : public Patch
  268.     {
  269.         typedef void (*FunType1)(LinkType*);
  270.         FunType1 fun;
  271.         
  272.         Patch1(FunType1 fn, Patch* nxt = NULL) : Patch(nxt), fun(fn) {}
  273.         
  274.         void run(VarPtr link) 
  275.         { 
  276.             fun( static_cast<LinkType*>(link.ptr) ); 
  277.         }
  278.     };
  279.     
  280.     
  281.     template <class ObjType, class LinkType>
  282.         struct Patch2 : public Patch
  283.     {
  284.         typedef void (ObjType::*FunType2)(LinkType*);
  285.         ObjType* obj;
  286.         FunType2 fun;
  287.         
  288.         Patch2(ObjType* ob, FunType2 fn, Patch* nxt = NULL) : Patch(nxt), obj(ob), fun(fn) {}
  289.  
  290.         void run(VarPtr link)
  291.         {
  292.             (obj->*fun)( static_cast<LinkType*>(link.ptr) ); 
  293.         }
  294.     };
  295.     
  296.     
  297.     inline
  298.     void runPatches(Patch*& list, VarPtr link)
  299.     {
  300.         while (list)
  301.         {
  302.             Patch* nxt = list->next;
  303.             list->run(link);
  304.             delete list;
  305.             list = nxt;
  306.         }
  307.     }
  308.     
  309.     inline
  310.     void deletePatches(std::map<Xml_string, Patch*>& patches)
  311.     {
  312.         std::map<Xml_string, Patch*>::iterator it;
  313.         for (it = patches.begin(); it != patches.end(); ++it)
  314.         {
  315.             Patch* list = it->second;
  316.             while (list)
  317.             {
  318.                 Patch* nxt = list->next;
  319.                 delete list;
  320.                 list = nxt;
  321.             }
  322.         }
  323.         patches.clear();
  324.     }
  325.  
  326.     
  327. //    template<> class Patch1<void>;
  328. //    template<> class Patch2<VarPtr,void>;
  329.     
  330. } //namespace PRIVATE
  331.  
  332.  
  333.  
  334. template<class ObjType>
  335. inline
  336. ObjType*  Digester::lookup(const Xml_string& idref) 
  337. { 
  338.     using namespace PRIVATE;
  339.  
  340.     std::map<Xml_string, VarPtr>::iterator cell = storage.find(idref);
  341.     if (cell == storage.end())
  342.     {
  343. #ifdef DESAXE_DEBUG
  344.         std::cerr << "lookup[" << idref << "]-> NULL\n";
  345. #endif
  346.         return NULL;
  347.     }
  348.     else
  349.     {
  350.         chkcell<ObjType> (cell->second);
  351. #ifdef DESAXE_DEBUG
  352.         std::cerr << "lookup[" << idref << "]-> " << static_cast<ObjType*>(cell->second.ptr) << "\n";
  353. #endif
  354.         return static_cast<ObjType*>(cell->second.ptr);
  355.     }
  356. }
  357.  
  358.  
  359.  
  360. template<class ObjType>
  361. inline
  362. void Digester::store(const Xml_string& idref, ObjType* obj) 
  363. {
  364.     using namespace PRIVATE;
  365. #ifdef DESAXE_DEBUG
  366.     std::cerr << "store[" << idref << "] <- " << obj << "\n";
  367. #endif
  368.     storage[idref] = mkcell(obj);
  369.     runPatches(patches[idref], storage[idref]);
  370. }
  371.  
  372.  
  373.  
  374. template<class LinkType>
  375. void Digester::patchCall(const Xml_string& idref, void (*fun)(LinkType*) )
  376. {
  377.     using namespace PRIVATE;
  378.     
  379.     std::map<Xml_string, VarPtr>::iterator cell = storage.find(idref);
  380.     if (cell == storage.end())
  381.     {
  382.         patches[idref] = new Patch1<LinkType>(fun, patches[idref] );
  383.     }
  384.     else
  385.     {
  386.         Patch1<LinkType>(fun).run(cell->second);
  387.     }
  388. }
  389.  
  390.  
  391. template<class ObjType, class LinkType>
  392. void Digester::patchInvoke(const Xml_string& idref, ObjType* obj, void (ObjType::*fun)(LinkType*) )
  393. {
  394.     using namespace PRIVATE;
  395.     
  396.     std::map<Xml_string, VarPtr>::iterator cell = storage.find(idref);
  397.     if (cell == storage.end())
  398.     {
  399.         patches[idref] = new Patch2<ObjType,LinkType>(obj, fun, patches[idref] );
  400.     }
  401.     else
  402.     {
  403.         Patch2<ObjType,LinkType>(obj, fun).run(cell->second);
  404.     }
  405. }
  406.  
  407. } // namespace desaxe
  408.  
  409. #endif
  410.